home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d11 / vmoire14.arc / VGA.INC < prev    next >
Text File  |  1991-04-21  |  28KB  |  684 lines
  1. ;
  2. ;       VGA.INC
  3. ;
  4. ;       declares the VGA-specific procedures used by VGAMoire.
  5. ;
  6.  
  7.  
  8.  
  9. MaxBound        equ     8               ;velocity variables are in range [-MaxBound,-MinBound] || [MinBound,MaxBound]
  10. MinBound        equ     3
  11.  
  12.  
  13. BytesPerLine    equ     80              ;bytes in one horizontal line
  14. VideoBufferSeg  equ     0a000h          ;segment of video buffer
  15. CGenRAMSeg      equ     0a000h          ;segment of character generator RAM
  16. TextBufferSeg   equ     0b000h          ;text memory starts here
  17. OriginOffset    equ     0               ;byte offset of (0,0)
  18. ByteOffsetShift equ     3               ;used to convert pixels to byte offset
  19. RMWbits         equ     0               ;value for Data Rotate/Func Select reg
  20.  
  21.  
  22.  
  23. MaxY            dw      479             ;maximum y-coordinate
  24. MaxX            dw      639             ;maximum x-coordinate
  25.  
  26.  
  27.  
  28. refresh proc    near                    ;enable/disable screen refresh
  29. ;       call with al = 00h --> enable refresh
  30. ;                    = 01h --> disable refresh
  31.         mov     ah,12h
  32.         mov     bl,36h
  33.         int     10h
  34.         ret
  35. refresh endp
  36.  
  37.  
  38.  
  39. getDAC  proc    near                    ;read video DAC color registers
  40. ;       ARGS:   al = video DAC color register to start at
  41. ;               cx = 3 * (number of registers to read)
  42. ;               es:di -> where to store registers read
  43.         mov     dx,03c7h                ;set video DAC read
  44.         cli                             ;disable interrupts
  45.         out     dx,al
  46.         mov     dx,03c9h                ;read video DAC color registers
  47. @@vDACget:
  48.         in      al,dx                   ;get color register value
  49.         and     al,3fh                  ;mask off the upper 2 bits
  50.         stosb                           ;store it
  51.         loop    @@vDACget               ;loop until done
  52.         sti                             ;enable interrupts
  53.         ret
  54. getDAC  endp
  55.  
  56.  
  57.  
  58. setDAC  proc    near                    ;set video DAC color registers
  59. ;       ARGS:   al = video DAC color register to start at
  60. ;               cx = 3 * (number of registers to write)
  61. ;               ds:si -> where to get values to write
  62.         mov     dx,03c8h                ;set video DAC write
  63.         cli                             ;disable interrupts
  64.         out     dx,al
  65.         mov     dx,03c9h                ;write video DAC color registers
  66. @@vDACset:
  67.         lodsb                           ;get stored video DAC color values
  68.         out     dx,al                   ;write value to video DAC color reg
  69.         loop    @@vDACset               ;loop until done
  70.         sti                             ;enable interrupts
  71.         ret
  72. setDAC  endp
  73.  
  74.  
  75.  
  76. SETCOLORS       macro
  77.         mov     si,offset blackcolor    ;where to get video DAC color defs from
  78.         mov     al,0                    ;set video DAC color regs 0 thru 5
  79.         mov     cx,6*3
  80.         call    setDAC
  81.         mov     al,20                   ;set video DAC color reg 20
  82.         mov     cx,1*3
  83.         call    setDAC
  84.         mov     al,7                    ;set video DAC color reg 7
  85.         mov     cx,1*3
  86.         call    setDAC
  87.         mov     al,56                   ;set video DAC color regs 56 thru 63
  88.         mov     cx,8*3
  89.         call    setDAC
  90. endm
  91.  
  92.  
  93.  
  94. CGenModeSet     proc    near
  95.         push    si
  96.         push    ds
  97.         push    cs                      ;set up addressibility for our data
  98.         pop     ds
  99.         ; Program the Sequencer
  100.         cli                             ;disable interrupts
  101.         mov     dx,3c4h                 ;Sequencer port address
  102.         mov     si,offset @@SeqParms
  103.         mov     cx,4
  104. @@L01:
  105.         lodsw                           ;ah=val. for Seq. reg.,  al=reg. num.
  106.         out     dx,ax
  107.         loop    @@L01
  108.         sti                             ;enable interrupts
  109.         ; Program the Graphics Controller
  110.         mov     dl,0ceh                 ;dx=3ceh (Graphics Controller port address)
  111.         mov     si,offset @@GCParms
  112.         mov     cx,3
  113. @@L02:
  114.         lodsw
  115.         out     dx,ax
  116.         loop    @@L02
  117.         pop     ds
  118.         pop     si
  119.         ret
  120. @@SeqParms      dw      0100h           ;synchronous reset
  121.                 dw      0402h           ;CPU writes only to map 2
  122.                 dw      0704h           ;sequential addressing
  123.                 dw      0300h           ;clear synchronous reset
  124. @@GCParms       dw      0204h           ;select map 2 for CPU reads
  125.                 dw      0005h           ;disable odd-even addressing
  126.                 dw      0006h           ;map starts at A000:0000
  127. CGenModeSet     endp
  128.  
  129.  
  130.  
  131. CGenModeClear   proc    near
  132.         push    si
  133.         push    ds
  134.         push    cs                      ;set up addressibility for our data
  135.         pop     ds
  136.         ; Program the Sequencer
  137.         cli                             ;disable interrupts
  138.         mov     dx,3c4h                 ;Sequencer port address
  139.         mov     si,offset @@SeqParms
  140.         mov     cx,4
  141. @@L01:
  142.         lodsw                           ;ah=val. for Seq. reg.,  al=reg. num.
  143.         out     dx,ax
  144.         loop    @@L01
  145.         sti                             ;enable interrupts
  146.         ; Program the Graphics Controller
  147.         mov     dl,0ceh                 ;dx=3ceh (Graphics Controller port address)
  148.         mov     si,offset @@GCParms
  149.         mov     cx,3
  150. @@L02:
  151.         lodsw
  152.         out     dx,ax
  153.         loop    @@L02
  154.         mov     ah,0fh                  ;get video mode
  155.         int     10h
  156.         cmp     al,7
  157.         jne     @@L03
  158.         mov     ax,0806h                ;program Graphics Controller
  159.         out     dx,ax                   ;  to start map at B000:0000
  160. @@L03:
  161.         pop     ds
  162.         pop     si
  163.         ret
  164. @@SeqParms      dw      0100h           ;synchronous reset
  165.                 dw      0302h           ;CPU writes to maps 0 and 1
  166.                 dw      0304h           ;odd-even addressing
  167.                 dw      0300h           ;clear synchronous reset
  168. @@GCParms       dw      0004h           ;select map 0 for CPU reads
  169.                 dw      1005h           ;enable odd-even addressing
  170.                 dw      0e06h           ;map starts at B800:0000
  171. CGenModeClear   endp
  172.  
  173.  
  174.  
  175. PixelAddr10     proc    near            ;gets address of pixel
  176. ;       ARGS:   AX = y-coordinate
  177. ;               BX = x-coordinate
  178. ;       RETS:   AH = bit mask
  179. ;               BX = byte offset in buffer
  180. ;               CL = number of bits to shift left
  181. ;               ES = video buffer segment
  182.         mov     cl,bl                   ;cl = low-order byte of x
  183.         push    dx                      ;preserve dx
  184.         mov     dx,BytesPerLine         ;ax = y*BytesPerLine
  185.         mul     dx
  186.         pop     dx
  187.         shr     bx,1
  188.         shr     bx,1
  189.         shr     bx,1                    ;bx = x/8
  190.         add     bx,ax                   ;bx = y*BytesPerLine + x/8
  191. ;        add     bx,OriginOffset         ;bx = byte offset in video buffer
  192.         mov     ax,VideoBufferSeg
  193.         mov     es,ax                   ;es:bx = byte address of pixel
  194.         and     cl,7                    ;cl = x&7
  195.         xor     cl,7                    ;cl = number of bits to shift left
  196.         mov     ah,1                    ;ah = unshifted bit mask
  197.         ret
  198. PixelAddr10     endp
  199.  
  200.  
  201.                     
  202. Line10  proc    near
  203.         ARG     ARGx1, ARGy1, ARGx2, ARGy2, ARGn:BYTE = ARGS            ;declare arguments
  204.         LOCAL   VARvertincr, VARincr1, VARincr2, VARroutine = VARS      ;declare local variables
  205.         push    bp
  206.         mov     bp,sp                   ;save stack context
  207.         sub     sp,VARS                 ;allocate space for local variables
  208.         push    si
  209.         push    di
  210.         ; configure the Graphics Controller
  211.         mov     dx,3ceh                 ;dx = Graphics Controller port addr
  212.         mov     ah,[ARGn]               ;ah = pixel value
  213.         xor     al,al                   ;al = Set/Reset Register number
  214.         out     dx,ax
  215.         mov     ax,0f01h                ;ah = 1111b (bit plane mask for Enable Set/Reset)
  216.         out     dx,ax                   ;al = Enable Set/Reset Register #
  217.         mov     ah,RMWbits              ;bits 3 and 4 of ah = function
  218.         mov     al,3                    ;al = Data Rotate/Func Select reg #
  219.         out     dx,ax
  220.         ; check for vertical line
  221.         mov     si,BytesPerLine         ;increment for video buffer
  222.         mov     cx,[ARGx2]
  223.         sub     cx,[ARGx1]              ;cx = x2-x1
  224.         jz      VertLine10              ;jump if vertical line
  225.         ; force x1<x2
  226.         jns     @@L01                   ;jump if x2>x1
  227.         neg     cx                      ;cx = x1-x2
  228.         mov     bx,[ARGx2]              ;exchange x1 and x2
  229.         xchg    bx,[ARGx1]
  230.         mov     [ARGx2],bx
  231.         mov     bx,[ARGy2]              ;exchange y1 and y2   [check first??]
  232.         xchg    bx,[ARGy1]              ;these are the two lines i missed
  233.         mov     [ARGy2],bx
  234.         ; calculate dy = ABS(y2-y1)
  235. @@L01:
  236.         mov     bx,[ARGy2]
  237.         sub     bx,[ARGy1]              ;bx = y2-y1
  238.         jz      HorizLine10             ;jump if horizontal line
  239.         jns     @@L03                   ;jump if slope is positive
  240.         neg     bx                      ;bx = y1-y2
  241.         neg     si                      ;negate increment for buffer interleave
  242.         ; select appropriate routine for slope of line
  243. @@L03:
  244.         mov     [VARvertincr],si        ;save vertical increment
  245.         mov     [VARroutine],offset LoSlopeLine10
  246.         cmp     bx,cx
  247.         jle     @@L04                   ;jump if dy<=dx (slope<=1)
  248.         mov     [VARroutine],offset HiSlopeLine10
  249.         xchg    bx,cx                   ;exchange dy and dx
  250.         ; calculate initial decision variable and increments
  251. @@L04:
  252.         shl     bx,1                    ;bx = 2*dy
  253.         mov     [VARincr1],bx           ;incr1 = 2*dy
  254.         sub     bx,cx
  255.         mov     si,bx                   ;si = 2*dy-dx
  256.         sub     bx,cx
  257.         mov     [VARincr2],bx           ;incr2 = 2*(dy-dx)
  258.         ; calculate first pixel address
  259.         push    cx                      ;preserve register
  260.         mov     ax,[ARGy1]              ;AX = y
  261.         mov     bx,[ARGx1]              ;BX = x
  262.         call    PixelAddr10             ;ah = bit mask
  263.                                         ;es:bx -> buffer
  264.                                         ;cl = # bits to shift left
  265.         mov     di,bx                   ;es:di -> buffer
  266.         shl     ah,cl                   ;ah = bit mask in proper position
  267.         mov     bl,ah                   ;ah,bl = bit mask
  268.         mov     al,8                    ;al = Bit Mask Register number
  269.         pop     cx                      ;restore register
  270.         inc     cx                      ;cx = # of pixels to draw
  271.         jmp     [VARroutine]            ;jump to appropriate routine for slope
  272.  
  273. VertLine10:                             ;routine for vertical lines
  274.         mov     ax,[ARGy1]              ;ax = y1
  275.         mov     bx,[ARGy2]              ;bx = y2
  276.         mov     cx,bx
  277.         sub     cx,ax                   ;cx = dy
  278.         jge     @@L31                   ;jump if dy>=0
  279.         neg     cx                      ;force dy>=0
  280.         mov     ax,bx                   ;ax = y2
  281. @@L31:
  282.         inc     cx                      ;cx = # of pixels to draw
  283.         mov     bx,[ARGx1]              ;bx = x
  284.         push    cx                      ;preserve register
  285.         call    PixelAddr10             ;ah = bit mask
  286.                                         ;es:bx -> buffer
  287.                                         ;cl = # bits to shift left
  288.         ; set up Graphics Controller
  289.         shl     ah,cl                   ;ah = bit mask in proper position
  290.         mov     al,8                    ;al = Bit Mask reg number
  291.         out     dx,ax
  292.         pop     cx                      ;restore register
  293.         ; draw the line
  294. @@L32:
  295.         or      es:[bx],al              ;set pixel
  296.         add     bx,si                   ;increment to next line
  297.         loop    @@L32
  298.         jmp     Lexit
  299.  
  300. HorizLine10:                            ;routine for horizontal lines (slope=0)
  301.         push    ds                      ;preserve ds
  302.         mov     ax,[ARGy1]
  303.         mov     bx,[ARGx1]
  304.         call    PixelAddr10             ;ah = bit mask
  305.                                         ;es:bx -> buffer
  306.                                         ;cl = # bits to shift left
  307.         mov     di,bx                   ;es:di -> buffer
  308.         mov     dh,ah                   ;dh = unshifted bit mask for leftmost byte
  309.         not     dh
  310.         shl     dh,cl                   ;dh = reverse bit make for first byte
  311.         not     dh                      ;dh = bit mask for first byte
  312.         mov     cx,[ARGx2]
  313.         and     cl,7
  314.         xor     cl,7                    ;cl = number of bits to shift left
  315.         mov     dl,0ffh                 ;dl = unshifted bit mask for rightmost byte
  316.         shl     dl,cl                   ;dl = bit mask for last byte
  317.         ; determine byte offset of first and last pixel in the line
  318.         mov     ax,[ARGx2]              ;ax = x2
  319.         mov     bx,[ARGx1]              ;bx = x1
  320.         mov     cl,ByteOffsetShift      ;number of bits to shift to convert pixels to bytes
  321.         shr     ax,cl                   ;ax = byte offset of x2
  322.         shr     bx,cl                   ;bx = byte offset of x1
  323.         mov     cx,ax
  324.         sub     cx,bx                   ;cx = (# bytes in line) -1
  325.         ; get Graphics Controller port address into dx
  326.         mov     bx,dx                   ;bh = bit mask for first byte
  327.                                         ;bl = bit mask for last byte
  328.         mov     dx,3ceh                 ;dx = Graphics Controller port
  329.         mov     al,8                    ;al = Bit Mask Register number
  330.         ; make video buffer addressable through ds:si
  331.         push    es
  332.         pop     ds
  333.         mov     si,di                   ;ds:si -> video buffer
  334.         ; set pixels in leftmost byte of the line
  335.         or      bh,bh
  336.         js      @@L43                   ;jump if byte-aligned (x1 is leftmost pixel in byte)
  337.         or      cx,cx
  338.         jnz     @@L42                   ;jump if more than one byte in the line
  339.         and     bl,bh                   ;bl = bit mask for the line
  340.         jmp     short @@L44
  341. @@L42:
  342.         mov     ah,bh                   ;ah = bit mask for 1st byte
  343.         out     dx,ax                   ;update Graphics Controller
  344.         movsb                           ;update bit planes
  345.         dec     cx
  346.         ; use a fast 8086 machine instruction to draw the remainder of the line
  347. @@L43:
  348.         mov     ah,11111111b            ;ah = bit mask
  349.         out     dx,ax                   ;update Bit Mask Register
  350.         rep     movsb                   ;update all pixels in the line
  351.         ; set pixels in the rightmost byte of the line
  352. @@L44:
  353.         mov     ah,bl                   ;ah = bit mask for last byte
  354.         out     dx,ax                   ;update Graphics Controller
  355.         movsb                           ;update bit planes
  356.         pop     ds                      ;restore ds
  357.         jmp     short Lexit
  358.  
  359.                                         ;es:di -> video buffer
  360.                                         ;al = Bit Mask Register number
  361.                                         ;bl = bit mask for 1st pixel
  362.                                         ;cx = # of pixels to draw
  363.                                         ;dx = Graphics Controller port addr
  364.                                         ;si = decision variable
  365. LoSlopeLine10:                          ;routine for dy>=dx (slope<=1)
  366. @@L10:
  367.         mov     ah,bl                   ;ah = bit mask for next pixel
  368. @@L11:
  369.         or      ah,bl                   ;mask current pixel position
  370.         ror     bl,1                    ;rotate pixel value
  371.         jc      @@L14                   ;jump if bit mask rotated to leftmost position
  372.         ; bit mask not shifted out
  373.         or      si,si                   ;test sign of d
  374.         jns     @@L12                   ;jump if d>=0
  375.         add     si,[VARincr1]           ;d = d+incr1
  376.         loop    @@L11
  377.         out     dx,ax                   ;update Bit Mask Register
  378.         or      es:[di],al              ;set remaining pixel(s)
  379.         jmp     short Lexit
  380. @@L12:
  381.         add     si,[VARincr2]           ;d = d+incr2
  382.         out     dx,ax                   ;update Bit Mask Register
  383.         or      es:[di],al              ;update bit planes
  384.         add     di,[VARvertincr]        ;increment y
  385.         loop    @@L10
  386.         jmp     short Lexit
  387.         ; bit mask shifted out
  388. @@L14:
  389.         out     dx,ax                   ;update Bit Mask Register ...
  390.         or      es:[di],al              ;update bit planes
  391.         inc     di                      ;increment x
  392.         or      si,si                   ;test sign of d
  393.         jns     @@L15                   ;jump if non-negative
  394.         add     si,[VARincr1]           ;d = d+incr1
  395.         loop    @@L10
  396.         jmp     short Lexit
  397. @@L15:
  398.         add     si,[VARincr2]           ;d = d+incr2
  399.         add     di,[VARvertincr]        ;vertical increment
  400.         loop    @@L10
  401.         jmp     short Lexit
  402.  
  403.                                         ;es:di -> video buffer
  404.                                         ;ah = bit mask for 1st pixel
  405.                                         ;al = Bit Mask Register number
  406.                                         ;cx = # of pixels to draw
  407.                                         ;dx = Graphics Controller port addr
  408.                                         ;si = decision variable
  409. HiSlopeLine10:                          ;routine for dy<dx (slope>1)
  410.         mov     bx,[VARvertincr]        ;bx = y-increment
  411. @@L21:
  412.         out     dx,ax                   ;update Bit Mask Register
  413.         or      es:[di],al              ;update bit planes
  414.         add     di,bx                   ;increment y
  415. @@L22:
  416.         or      si,si                   ;test sign of d
  417.         jns     @@L23                   ;jump if d>=0
  418.         add     si,[VARincr1]           ;d = d+incr1
  419.         loop    @@L21
  420.         jmp     short Lexit
  421. @@L23:
  422.         add     si,[VARincr2]           ;d = d+incr2
  423.         ror     ah,1                    ;rotate bit mask
  424.         adc     di,0                    ;increment di if when mask rotated to leftmost pixel position
  425.         loop    @@L21
  426.  
  427.         ; restore default Graphics Controller state and return to caller
  428. Lexit:  xor     ax,ax                   ;ah = 0, al = 0
  429.         out     dx,ax                   ;restore Set/Reset Register
  430.         inc     ax                      ;ah = 0, al = 1
  431.         out     dx,ax                   ;restore Enable Set/Reset Register
  432.         mov     al,3                    ;ah = 0, al = 3
  433.         out     dx,ax                   ;al = Data Rotate/Func Select reg #
  434.         mov     ax,0ff08h               ;ah = 11111111b, al = 8
  435.         out     dx,ax                   ;restore Bit Mask Register
  436.         pop     di                      ;restore registers and return
  437.         pop     si
  438.         mov     sp,bp                   ;deallocate local variables
  439.         pop     bp                      ;restore stack context
  440.         ret     ARGS                    ;return and pop arguments from stack
  441. Line10  endp
  442.  
  443.  
  444.  
  445. copyfont        proc    near            ;al=0 to restore, 1 to save
  446.         cmp     [fontblocks],0          ;do we save any character generator RAM
  447.         jnz     @@yesfont
  448.         jmp     @@nofont
  449. @@yesfont:
  450.         push    ds                      ;save ds
  451.         push    ax
  452.         mov     ax,4400h                ;map logical EMS pages to physical page frame
  453.         mov     cl,[fontblocks]         ;number of blocks of font RAM to save
  454.         xor     ch,ch
  455.         inc     cl                      ;round up and
  456.         shr     cl,1                    ;  convert to num. of EMS pages needed
  457.         xor     bh,bh
  458.         mov     bl,[useEMS]             ;al=logical page to start at
  459. @@maploop:
  460.         push    ax                      ;map the EMS pages
  461.         push    bx
  462.         mov     dx,[EMShandle]
  463.         int     67h
  464.         or      ah,ah
  465.         jnz     @@maperror              ;@@maperror cleans up and returns with carry set, to indicate a failure
  466.         pop     bx
  467.         pop     ax
  468.         inc     bl
  469.         inc     al
  470.         loop    @@maploop
  471.         mov     bx,[storetext]
  472.         xor     dx,dx
  473.         pop     ax
  474.         or      al,al                   ;copy from or to font RAM
  475.         jz      @@restore
  476.         mov     es,bx                   ;make pointer to save area
  477.         mov     di,dx
  478.         mov     bx,CGenRAMSeg           ;points to character RAM on map 2
  479.         mov     ds,bx
  480.         xor     si,si
  481.         jmp     @@copyfont
  482. @@restore:                              ;copy font RAM back
  483.         mov     ds,bx
  484.         mov     si,dx
  485.         mov     bx,CGenRAMSeg           ;points to character RAM on map 2
  486.         mov     es,bx
  487.         xor     di,di
  488. @@copyfont:
  489.         call    CGenModeSet             ;program VGA card to allow r/w access to character RAM
  490.         mov     ah,cs:[fontblocks]      ;number of blocks of font RAM to copy
  491.         xor     al,al
  492.         mov     cl,4
  493.         shl     ah,cl
  494.         mov     cx,ax
  495.         rep     movsw                   ;copy font RAM
  496.         call    CGenModeClear           ;program VGA card back to normal
  497.         pop     ds                      ;restore ds
  498. @@nofont:
  499.         clc
  500.         ret
  501. @@maperror:
  502.         pop     bx                      ;pop saved registers
  503.         pop     ax
  504.         pop     ax
  505.         pop     ds
  506.         call    freebuf
  507.         stc
  508.         ret
  509. copyfont        endp
  510.  
  511.  
  512.  
  513. loadfont        proc                    ;loads a ROM font using a best-fit algorithm
  514.         push    es
  515.         mov     es,[keybuff]            ;set es=0000:0000
  516.         mov     ax,word ptr es:[485h]
  517.         cmp     ax,8                    ;8x8 font?
  518.         ja      @@8x14
  519.         mov     al,02h                          ; if font <= 8x8, load 8x8
  520.         jmp     @@loadfont
  521. @@8x14:
  522.         cmp     ax,14                   ;8x14 font?
  523.         ja      @@8x16
  524.         mov     al,01h                          ; if font <= 8x14, load 8x14
  525.         jmp     @@loadfont
  526. @@8x16:
  527.         mov     al,04h                          ; if font > 8x14, load 8x16
  528. @@loadfont:
  529.         mov     ah,11h                  ;load ROM font (al and bl are already set appropriately)
  530.         int     10h
  531.         pop     es
  532.         ret
  533. loadfont        endp
  534.  
  535.  
  536.  
  537. copytext        proc    near            ;copy text from buffer to buffer
  538.         push    ax
  539.         or      al,al
  540.         jnz     @@store
  541.         mov     ax,1c02h                ;restore video state
  542.         mov     cx,7                    ;all video info
  543.         mov     bx,[storetext]
  544.         mov     es,bx
  545.         mov     bx,[buffersize]         ;es:bx -> buffer for video state
  546.         add     bx,[mousesize]          ;index past the mouse state save buffer
  547.         push    bx                      ;store offset temporarily
  548.         int     10h
  549.         mov     ah,1bh
  550.         xor     bx,bx                   ;   (don't need to set es because it retains its value through the previous int)
  551.         pop     di                      ;reuse video state buffer to get some video info
  552.         int     10h                     ;get some video info
  553.         mov     bl,byte ptr es:[2bh]
  554.         cmp     [fontblocks],bl         ;did we save the primary font block?
  555.         jg      @@secondary             ;if so, check about the secondary font block
  556.         call    loadfont                ;load the appropriate ROM font
  557. @@secondary:
  558.         cmp     bl,byte ptr es:[2ch]    ;if primary and secondary font blocks are the same
  559.         je      @@store                 ;  then skip processing the block a second time
  560.         mov     bl,byte ptr es:[2ch]
  561.         cmp     fontblocks,bl           ;did we save the secondary font block?
  562.         jg      @@store                 ;if so, we're all set
  563.         call    loadfont                ;load the appropriate ROM font
  564. @@store:
  565.         pop     ax
  566.         push    ds                      ;save ds
  567.         push    [buffersize]            ;save video text buffer size
  568.         push    [textbuff]              ;save textbuff
  569.         mov     bx,[storetext]          ;buffer is at bx:dx
  570.         xor     dx,dx
  571.         or      al,al                   ;copy in which direction
  572.         jz      @@restore
  573.         push    cs                      ;set es = cs
  574.         pop     es
  575.         pop     ds                      ;ds = textbuff
  576.         xor     si,si
  577.         mov     es,bx                   ;into bx:dx = es:di
  578.         mov     di,dx
  579.         jmp     @@copytext
  580. @@restore:
  581.         push    cs                      ;set ds = cs
  582.         pop     ds
  583.         pop     es                      ;es = textbuff
  584.         xor     di,di
  585.         mov     ds,bx                   ;copy this buffer
  586.         mov     si,dx
  587. @@copytext:
  588.         pop     cx                      ;cx = buffersize
  589.         rep     movsb                   ;copy text
  590.         pop     ds                      ;restore ds
  591.         or      al,al
  592.         jz      @@done
  593.         mov     ax,1c01h                ;save video state
  594.         mov     cx,7                    ;all video info
  595.         mov     bx,[storetext]
  596.         mov     es,bx
  597.         mov     bx,[buffersize]         ;es:bx -> buffer for video state
  598.         add     bx,[mousesize]          ;index past the mouse state save buffer
  599.         int     10h
  600. @@done:
  601.         ret
  602. copytext        endp
  603.  
  604.  
  605.  
  606. STORE   macro
  607.         mov     al,1                    ;set al = 1 to
  608.         call    copytext                ;  copy text from video area to our buffer
  609.         mov     al,1                    ;set al = 1 to
  610.         call    copyfont                ;  copy font RAM to our buffer
  611.         jc      @@gofail
  612. endm
  613.  
  614.  
  615.  
  616. SETMODE macro
  617.         mov     ax,12h                  ;set graphics mode (VGA 640x480 16 color)
  618.         int     10h                     ;  (seems to work w/EGA, too...)
  619. endm
  620.  
  621.  
  622.  
  623. RESTORE macro
  624.         ; try to restore from EMS, first, if [fontblocks] is set, but if not possible, do it the old-fashioned way
  625.         xor     al,al                   ;set al = 0 to signal restore
  626.         call    copyfont
  627.         call    getbuf
  628.         jc      @@fail                  ;if couldn't access buffer, we can't do anything more
  629.         xor     al,al                   ;set al = 0 to signal restore
  630.         call    copytext
  631.         push    es
  632.         mov     ax,17h                  ;restore mouse state
  633.         push    [storetext]             ;get segment of save buffer
  634.         pop     es
  635.         mov     dx,[buffersize]         ;offset past stored video screen
  636.         int     33h
  637.         pop     es
  638.         mov     ax,1                    ;show pointer (only actually does if it was showing before)
  639.         int     33h
  640.         call    freebuf                 ;restore EMS state if used
  641. endm
  642.  
  643.  
  644.  
  645. public  ARGS
  646. ;public  ARGn
  647. ;public  ARGx1
  648. ;public  ARGx2
  649. ;public  ARGy1
  650. ;public  ARGy2
  651. public  ByteOffsetShift
  652. public  BytesPerLine
  653. public  CGenModeClear
  654. public  CGenModeSet
  655. public  CGenRAMSeg
  656. public  HiSlopeLine10
  657. public  HorizLine10
  658. public  Lexit
  659. public  Line10
  660. public  LoSlopeLine10
  661. public  MaxBound
  662. public  MaxX
  663. public  MaxY
  664. public  MinBound
  665. public  OriginOffset
  666. public  PixelAddr10
  667. public  RMWbits
  668. public  TextBufferSeg
  669. ;public  VARincr1
  670. ;public  VARincr2
  671. ;public  VARroutine
  672. ;public  VARvertincr
  673. public  VertLine10
  674. public  VideoBufferSeg
  675. public  copyfont
  676. public  copytext
  677. public  getDAC
  678. public  VARS
  679. public  loadfont
  680. public  refresh
  681. public  setDAC
  682.  
  683. ;______ eof ________________________________________________________ eof ______
  684.